/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


//
// Log4j uses the JUnit framework for internal unit testing. JUnit
// available from
//
//     http://www.junit.org
package org.apache.log4j.helpers;

import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.helpers.BoundedFIFO;
import org.apache.log4j.spi.LoggingEvent;


/**
   Unit test the {@link BoundedFIFO}.
   @author Ceki G&uuml;lc&uuml;
   @since 0.9.1 */
public class BoundedFIFOTestCase extends TestCase {
  static Logger cat = Logger.getLogger("x");
  static int MAX = 1000;
  static LoggingEvent[] e = new LoggingEvent[MAX];

  {
    for (int i = 0; i < MAX; i++) {
      e[i] = new LoggingEvent("", cat, Level.DEBUG, "e" + i, null);
    }
  }

  public BoundedFIFOTestCase(String name) {
    super(name);
  }

  public void setUp() {
  }

  /**
     Pattern: +++++..-----..
   */
  public void test1() {
    for (int size = 1; size <= 128; size *= 2) {
      BoundedFIFO bf = new BoundedFIFO(size);

      assertEquals(bf.getMaxSize(), size);
      assertNull(bf.get());

      int i;
      int j;
      int k;

      for (i = 1; i < (2 * size); i++) {
        for (j = 0; j < i; j++) {
          //System.out.println("Putting "+e[j]);
          bf.put(e[j]);
          assertEquals(bf.length(), (j < size) ? (j + 1) : size);
        }

        int max = (size < j) ? size : j;
        j--;

        for (k = 0; k <= j; k++) {
          //System.out.println("max="+max+", j="+j+", k="+k);
          assertEquals(bf.length(), ((max - k) > 0) ? (max - k) : 0);

          Object r = bf.get();

          //System.out.println("Got "+r);
          if (k >= size) {
            assertNull(r);
          } else {
            assertEquals(r, e[k]);
          }
        }
      }

      //System.out.println("Passed size="+size);
    }
  }

  /**
     Pattern: ++++--++--++
   */
  public void test2() {
    int size = 3;
    BoundedFIFO bf = new BoundedFIFO(size);

    bf.put(e[0]);
    assertEquals(bf.get(), e[0]);
    assertNull(bf.get());

    bf.put(e[1]);
    assertEquals(bf.length(), 1);
    bf.put(e[2]);
    assertEquals(bf.length(), 2);
    bf.put(e[3]);
    assertEquals(bf.length(), 3);
    assertEquals(bf.get(), e[1]);
    assertEquals(bf.length(), 2);
    assertEquals(bf.get(), e[2]);
    assertEquals(bf.length(), 1);
    assertEquals(bf.get(), e[3]);
    assertEquals(bf.length(), 0);
    assertNull(bf.get());
    assertEquals(bf.length(), 0);
  }

  int min(int a, int b) {
    return (a < b) ? a : b;
  }

  /**
     Pattern ++++++++++++++++++++ (insert only);
   */
  public void testResize1() {
    int size = 10;

    for (int n = 1; n < (size * 2); n++) {
      for (int i = 0; i < (size * 2); i++) {
        BoundedFIFO bf = new BoundedFIFO(size);

        for (int f = 0; f < i; f++) {
          bf.put(e[f]);
        }

        bf.resize(n);

        int expectedSize = min(n, min(i, size));
        assertEquals(bf.length(), expectedSize);

        for (int c = 0; c < expectedSize; c++) {
          assertEquals(bf.get(), e[c]);
        }
      }
    }
  }

  /**
     Pattern ++...+ --...-
   */
  public void testResize2() {
    int size = 10;

    for (int n = 1; n < (size * 2); n++) {
      for (int i = 0; i < (size * 2); i++) {
        for (int d = 0; d < min(i, size); d++) {
          BoundedFIFO bf = new BoundedFIFO(size);

          for (int p = 0; p < i; p++) {
            bf.put(e[p]);
          }

          for (int g = 0; g < d; g++) {
            bf.get();
          }

          // x = the number of elems in 
          int x = bf.length();

          bf.resize(n);

          int expectedSize = min(n, x);
          assertEquals(bf.length(), expectedSize);

          for (int c = 0; c < expectedSize; c++) {
            assertEquals(bf.get(), e[c + d]);
          }

          assertNull(bf.get());
        }
      }
    }
  }

  /**
     Pattern: i inserts, d deletes, r inserts
   */
  public void testResize3() {
    int size = 10;

    for (int n = 1; n < (size * 2); n++) {
      for (int i = 0; i < size; i++) {
        for (int d = 0; d < i; d++) {
          for (int r = 0; r < d; r++) {
            BoundedFIFO bf = new BoundedFIFO(size);

            for (int p0 = 0; p0 < i; p0++)
              bf.put(e[p0]);

            for (int g = 0; g < d; g++)
              bf.get();

            for (int p1 = 0; p1 < r; p1++)
              bf.put(e[i + p1]);

            int x = bf.length();

            bf.resize(n);

            int expectedSize = min(n, x);
            assertEquals(bf.length(), expectedSize);

            for (int c = 0; c < expectedSize; c++) {
              assertEquals(bf.get(), e[c + d]);
            }

            //assertNull(bf.get());
          }
        }
      }
    }
  }

 
}
